const express = require('express');
const router = express.Router();
const path = require('path'); // 调整引入顺序，确保path在使用前定义
const fs = require('fs');
const { generatePianoAudio } = require('../generatePianoAudio');

// 钢琴音频存储目录（与生成模块的输出目录保持一致）
const PIANO_AUDIO_DIR = path.join(__dirname, '../audio/piano');

// 确保存储目录存在（初始化时创建，避免生成音频时目录不存在）
if (!fs.existsSync(PIANO_AUDIO_DIR)) {
  try {
    fs.mkdirSync(PIANO_AUDIO_DIR, { recursive: true });
    console.log(`钢琴音频存储目录已创建: ${PIANO_AUDIO_DIR}`);
  } catch (err) {
    console.error(`创建钢琴音频目录失败: ${err.message}`);
  }
}

/**
 * @route POST /api/piano/generate
 * @desc 生成钢琴音色音频
 * @access Public
 */
router.post('/generate', async (req, res) => { // 补全路由定义
  try {
    const { frequency, duration: durationParam } = req.body;

    // 验证频率参数
    if (frequency === undefined || frequency === null) {
      return res.status(400).json({
        success: false,
        error: '缺少频率参数（frequency）',
      });
    }
    const frequencyNum = Number(frequency);
    if (isNaN(frequencyNum) || frequencyNum <= 0 || !isFinite(frequencyNum)) {
      return res.status(400).json({
        success: false,
        error: '频率参数必须是大于0的有效数字',
        details: `接收到的频率: ${frequency}`,
      });
    }

    // 解析并验证时长参数（默认1秒）
    const duration = Number(durationParam) || 1;
    if (isNaN(duration) || duration <= 0 || duration > 10) {
      return res.status(400).json({
        success: false,
        error: '无效的时长参数，时长必须为0-10秒的数值',
        details: `接收到的时长: ${durationParam}`,
      });
    }

    // 确保音频目录存在
    if (!fs.existsSync(PIANO_AUDIO_DIR)) {
      console.log('音频目录不存在，正在创建:', PIANO_AUDIO_DIR);
      fs.mkdirSync(PIANO_AUDIO_DIR, { recursive: true });
    }

    // 调用音频生成函数（传入频率、目录和时长）
    console.log(`开始生成 ${frequencyNum}Hz 钢琴音频，时长: ${duration}秒...`);
    const fileName = await generatePianoAudio(frequencyNum, PIANO_AUDIO_DIR, duration);
    if (!fileName) {
      throw new Error('音频生成成功但未返回文件名');
    }

    // 返回生成结果
    res.status(200).json({
      success: true,
      fileName,
      url: `/audio/piano/${encodeURIComponent(fileName)}`,
      message: `音频生成成功，文件名: ${fileName}`,
    });
  } catch (error) {
    const errorMsg = error.message || '未知错误';
    console.error('钢琴音频生成失败:', { 
      frequency: req.body?.frequency, 
      error: errorMsg, 
      stack: error.stack 
    });
    res.status(500).json({
      success: false,
      error: `生成钢琴音频时发生错误: ${errorMsg}`,
      details: error.message,
      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
    });
  }
});

/**
 * @route POST /api/piano/play
 * @desc 播放钢琴键音频（时长1秒）
 * @access Public
 */
router.post('/play', async (req, res) => {
  try {
    console.log('[API] 收到钢琴演奏请求，路径:/api/piano/play，方法:POST');
    console.log('[API] 请求体:', req.body);
    const { frequency, isBGM = false } = req.body;

    if (frequency === undefined || frequency === null) {
      return res.status(400).json({ 
        success: false,
        error: '缺少频率参数（frequency）' 
      });
    }
    const freqNum = Number(frequency);
    if (isNaN(freqNum) || freqNum <= 0 || !isFinite(freqNum)) {
      return res.status(400).json({
        success: false,
        error: '频率参数必须是大于0的有效数字',
      });
    }

    console.log(`开始生成 ${freqNum}Hz 钢琴音频（演奏模式，时长1秒）...`);
    if (isBGM) {
      // BGM模式：不保存文件，直接返回音频数据
      const wavData = await generatePianoAudio(freqNum, PIANO_AUDIO_DIR, 1, false);
      res.setHeader('Content-Type', 'audio/wav');
      return res.send(wavData);
    } else {
      // 普通模式：保存文件并返回URL
      const fileName = await generatePianoAudio(freqNum, PIANO_AUDIO_DIR, 1, true);
      // 验证文件是否生成成功
      const filePath = path.join(PIANO_AUDIO_DIR, fileName);
      if (!fs.existsSync(filePath)) {
        throw new Error(`音频文件未生成: ${filePath}`);
      }
      const fileStats = fs.statSync(filePath);
      if (fileStats.size === 0) {
        throw new Error(`生成的音频文件为空: ${filePath}`);
      }
      console.log(`音频文件生成成功: ${filePath}, 大小: ${fileStats.size} bytes`);
      res.json({
        success: true,
        fileName,
        url: `/audio/piano/${encodeURIComponent(fileName)}`,
        message: `音频生成成功，文件名: ${fileName}`,
      });
    }
  } catch (error) {
    console.error('钢琴音频生成失败:', error);
    res.status(500).json({
      success: false,
      error: '生成钢琴音频时发生错误',
      details: error.message,
      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
    });
  }
});

module.exports = router;